package com.gdlgxy.oa.bean;

/**
 * 学生的单链表
 */
public class StudentList implements SystemList {
    /**
     * 首节点
     */
    private Student first = null;

    /**
     * 指数当前的链表是否被删除
     */
    private boolean del = false;

    /**
     * 初始化学生链表
     */
    public StudentList() {
        /**
         * 创建链表的首节点
         */
        this.first = new Student(0, "");
    }

    /**
     * 添加学生
     * @param student 学生节点
     */
    public void studentAdd(Student student) {
        // 缓冲变量
        Student temp = first;

        while (null != temp.getNext()) {
            temp = temp.getNext();
        }
        temp.setNext(student);
    }

    /**
     * 删除学生
     * @param no 删除学生的编号
     */
    public void studentDel(int no) {
        // 缓冲遍历
        Student temp = first;
        while (true) {
            // 如果下一个节点是null，说明没有删除的节点
            if (temp.getNext() == null) {
                throw new RuntimeException("删除链表错误，没有" + no + "学生节点");
            } else if (temp.getNext().getNo() == no) {
                // 执行到这里，说明下一个节点是删除的节点
                temp.setNext(temp.getNext().getNext());
                del = true;
                break;
            }
            temp = temp.getNext();
        }
    }

    /**
     * 遍历链表，查询删除的节点（只能删除一个）
     * 演示：找到删除的节点（效率过低）
     * @param list 删除前的学生节点
     * @return 删除的学生编号
     */
    public int findStudentDel(StudentList list) {
        // 当前删除了节点的链表
        Student dtemp = first.getNext();
        // 还没有删除的节点链表
        Student ytemp = list.first.getNext();
        while (null != dtemp) {
            if (dtemp.getNo() == ytemp.getNo()) {
                dtemp = dtemp.getNext();
                ytemp = ytemp.getNext();
            } else {
                break;
            }
        }
        return ytemp.getNo();
    }

    /**
     * 只知道学生姓名，不知道编号，
     * 自动编号，将其添加到学生链表中
     * @param Sname 添加的学生姓名
     */
    public void snameAdd(String Sname) {
        int no;
        if (first.getNext() == null) {
            no = 1;
        }else{
            // 遍历单向链表到最后一个节点
            Student temp = first.getNext();
            while (null != temp.getNext()) {
                temp = temp.getNext();
            }
            // 执行到这里，说明当前节点是最后一个节点
            // 获取其编号+1就是下一个节点编号
            no = (temp.getNo()) + 1;
        }
        // 添加学生
        studentAdd(new Student(no, Sname));
    }

    /**
     * 获取学生链表的最后一个节点
     * @return 链表的最后一个节点
     */
    public Student studentLast() {
        // 遍历单向链表到最后一个节点
        Student temp = first.getNext();
        while (null != temp.getNext()) {
            temp = temp.getNext();
        }
        return temp;
    }

    /**
     * 根据编号查询学生，返回学生节点
     * @return 学生节点
     */
    public Student studentFind(int no){
        Student temp = first.getNext();
        while (temp.getNo()!=no){
            temp=temp.getNext();
        }
        // 执行到这里，说明当前节点为查找的节点
        return temp;
    }

    /**
     * 遍历链表，查询修改的节点（只能修改一个）
     * 演示：找到修改的节点（效率过低）
     * @param list 修改前的学生链表
     * @return 被修改前的学生节点
     */
    public Student findStudentUpdate(StudentList list){
        // 当前修改了节点的链表
        Student dtemp = first.getNext();
        // 还没有修改的节点链表
        Student ytemp = list.first.getNext();
        while (null != dtemp) {
            if (dtemp.equals(ytemp)) {
                dtemp = dtemp.getNext();
                ytemp = ytemp.getNext();
            } else {
                break;
            }
        }
        return dtemp;
    }


    public Student getFirst() {
        return first;
    }

    public void setFirst(Student first) {
        if (first != null) {
            this.first = first;
        }

    }
}
